/*
 *  This file is part of the Jikes RVM project (http://jikesrvm.org).
 *
 *  This file is licensed to You under the Eclipse Public License (EPL);
 *  You may not use this file except in compliance with the License. You
 *  may obtain a copy of the License at
 *
 *      http://www.opensource.org/licenses/eclipse-1.0.php
 *
 *  See the COPYRIGHT.txt file distributed with this work for information
 *  regarding copyright ownership.
 */
package org.mmtk.plan.compressor;

import org.mmtk.plan.TraceLocal;
import org.mmtk.plan.Trace;
import org.mmtk.plan.TransitiveClosure;
import org.mmtk.policy.Space;
import org.mmtk.policy.compressor.ReferenceFixer;
import org.mmtk.utility.Log;
import org.mmtk.utility.options.Options;
import org.mmtk.vm.VM;

import org.vmmagic.pragma.*;
import org.vmmagic.unboxed.*;

/**
 * This class implements the thread-local functionality for a transitive
 * closure over a mark-compact space during the forwarding phase.
 */
@Uninterruptible
public final class CompressorForwardTraceLocal extends TraceLocal {
  
  private ReferenceFixer referenceFixer;
  /**
   * Constructor
   */
  public CompressorForwardTraceLocal(Trace trace, CompressorCollector collector) {
    super(Compressor.SCAN_FORWARD, trace);
    referenceFixer = new ReferenceFixer(collector);
  }

  /****************************************************************************
   *
   * Externally visible Object processing and tracing
   */

  /**
   * Is the specified object live?
   *
   * @param object The object.
   * @return True if the object is live.
   */
  public boolean isLive(ObjectReference object) {
    if (object.isNull()) return false;
    if (Space.isInSpace(Compressor.MC0, object)) {
      return Compressor.markCopySpace0.isLive(object);
    }
    if (Space.isInSpace(Compressor.MC1, object)) {
      return Compressor.markCopySpace1.isLive(object);
    }
    return super.isLive(object);
  }

  /**
   * This method is the core method during the trace of the object graph.
   * The role of this method is to:
   *
   * 1. Ensure the traced object is not collected.
   * 2. If this is the first visit to the object enqueue it to be scanned.
   * 3. Return the forwarded reference to the object.
   *
   * In this instance, we refer objects in the mark-sweep space to the
   * msSpace for tracing, and defer to the superclass for all others.
   *
   * @param object The object to be traced.
   * @return The new reference to the same object instance.
   */
  @Inline
  public ObjectReference traceObject(ObjectReference object) {
    if (object.isNull()) return object;
    if (Space.isInSpace(Compressor.MC0, object))
      return Compressor.markCopySpace0.traceForwardObject(this, object);
    if (Space.isInSpace(Compressor.MC1, object))
      return Compressor.markCopySpace1.traceForwardObject(this, object);
    
    return super.traceObject(object);
  }

  /**
   * Will this object move from this point on, during the current trace ?
   *
   * @param object The object to query.
   * @return True if the object will not move.
   */
  public boolean willNotMoveInCurrentCollection(ObjectReference object) {
    return !Space.isInSpace(Compressor.MC0, object) &&  
           !Space.isInSpace(Compressor.MC1, object);
  }
  
  /**
   * Collectors that move objects <b>must</b> override this method.
   * It performs the deferred scanning of objects which are forwarded
   * during bootstrap of each copying collection.  Because of the
   * complexities of the collection bootstrap (such objects are
   * generally themselves gc-critical), the forwarding and scanning of
   * the objects must be dislocated.  It is an error for a non-moving
   * collector to call this method.
   *
   * @param object The forwarded object to be scanned
   */
  @Inline
  @Override
  protected void scanObject(ObjectReference object) {
    if (VM.VERIFY_ASSERTIONS && Options.verbose.getValue() >= 9) {
      Log.write("SO["); Log.write(object); Log.writeln("]");
    }
    VM.scanning.scanObject(referenceFixer, object);
    if (VM.VERIFY_ASSERTIONS && Options.verbose.getValue() >= 9) {
      Log.writeln("SO[end]"); 
    }
    super.scanObject(object);
  }

}
